/**
 * ID冲突处理工具
 * 用于处理数据库主键冲突问题
 */

/**
 * 检测是否为重复ID错误
 * @param {Error} error - 错误对象
 * @returns {boolean} 是否为重复ID错误
 */
export function isDuplicateIdError(error) {
  if (!error) return false;
  
  const errorMessage = error.message || error.toString();
  return errorMessage.includes('Duplicate entry') && errorMessage.includes('PRIMARY');
}

/**
 * 从错误信息中提取冲突的ID
 * @param {Error} error - 错误对象
 * @returns {string|null} 冲突的ID，如果没有找到则返回null
 */
export function extractConflictId(error) {
  if (!error) return null;
  
  const errorMessage = error.message || error.toString();
  const match = errorMessage.match(/Duplicate entry '([^']+)' for key/);
  return match ? match[1] : null;
}

/**
 * 生成新的唯一ID
 * @param {string} originalId - 原始ID
 * @param {Array} existingIds - 已存在的ID列表
 * @param {string} prefix - ID前缀（可选）
 * @returns {string} 新的唯一ID
 */
export function generateNewId(originalId, existingIds = [], prefix = '') {
  if (!originalId) return generateRandomId(prefix);
  
  // 尝试在原始ID后添加数字后缀
  let newId = originalId;
  let counter = 1;
  
  while (existingIds.includes(newId)) {
    // 如果原始ID已经是数字结尾，则递增
    if (/^\d+$/.test(originalId)) {
      newId = String(parseInt(originalId) + counter);
    } else {
      // 否则添加下划线和数字后缀
      newId = `${originalId}_${counter}`;
    }
    counter++;
  }
  
  return newId;
}

/**
 * 生成随机ID
 * @param {string} prefix - ID前缀（可选）
 * @returns {string} 随机ID
 */
export function generateRandomId(prefix = '') {
  const timestamp = Date.now();
  const random = Math.random().toString(36).substr(2, 9);
  return `${prefix}${timestamp}_${random}`;
}

/**
 * 处理ID冲突的API调用
 * @param {Function} apiCall - API调用函数
 * @param {Object} data - 请求数据
 * @param {Array} existingIds - 已存在的ID列表
 * @param {number} maxRetries - 最大重试次数
 * @returns {Promise} API调用结果
 */
export async function handleIdConflict(apiCall, data, existingIds = [], maxRetries = 3) {
  let retryCount = 0;
  
  while (retryCount < maxRetries) {
    try {
      return await apiCall(data);
    } catch (error) {
      if (isDuplicateIdError(error) && retryCount < maxRetries - 1) {
        const conflictId = extractConflictId(error);
        console.warn(`检测到ID冲突: ${conflictId}，正在生成新ID...`);
        
        // 生成新的ID
        if (data.lineId) {
          data.lineId = generateNewId(conflictId, existingIds);
        } else if (data.recptId) {
          data.recptId = generateNewId(conflictId, existingIds);
        }
        
        retryCount++;
        continue;
      }
      
      // 如果不是ID冲突错误或已达到最大重试次数，则抛出错误
      throw error;
    }
  }
  
  throw new Error('ID冲突处理失败，已达到最大重试次数');
}

/**
 * 批量处理ID冲突
 * @param {Array} dataList - 数据列表
 * @param {Function} apiCall - API调用函数
 * @param {Array} existingIds - 已存在的ID列表
 * @returns {Promise} 处理结果
 */
export async function handleBatchIdConflict(dataList, apiCall, existingIds = []) {
  const results = [];
  const errors = [];
  
  for (let i = 0; i < dataList.length; i++) {
    try {
      const data = { ...dataList[i] };
      const result = await handleIdConflict(apiCall, data, existingIds);
      results.push(result);
      
      // 更新已存在的ID列表
      if (result.data) {
        existingIds.push(result.data);
      }
    } catch (error) {
      console.error(`处理第${i + 1}条数据时发生错误:`, error);
      errors.push({
        index: i,
        data: dataList[i],
        error: error.message
      });
    }
  }
  
  return {
    success: results,
    errors: errors,
    hasErrors: errors.length > 0
  };
}
